M

MLOG

Deutsch

Entfesseln Sie serverloses Computing mit Google Cloud Functions. Dieser Leitfaden zu HTTP-Triggern vermittelt Entwicklern weltweit Wissen für skalierbare, ereignisgesteuerte Apps.

Google Cloud Functions: Ein umfassender Leitfaden zu HTTP-Triggern

Google Cloud Functions (GCF) ist eine serverlose Ausführungsumgebung, die es Ihnen ermöglicht, Cloud-Dienste zu erstellen und zu verbinden. Mit Cloud Functions schreiben Sie einfache, zweckgebundene Funktionen, die an Ereignisse gebunden sind, die von Ihrer Cloud-Infrastruktur und Ihren Diensten ausgegeben werden. Ihre Funktion wird ausgeführt, wenn das von Ihnen beobachtete Ereignis eintritt. Dieser Ansatz ermöglicht es Ihnen, ereignisgesteuerte Anwendungen zu entwickeln, ohne Server oder Laufzeiten verwalten zu müssen.

Eine der häufigsten Möglichkeiten, eine Cloud Function auszulösen, ist eine HTTP-Anfrage. Dieser Leitfaden führt Sie in die Welt der HTTP-Trigger in Google Cloud Functions ein und vermittelt Ihnen das Wissen zum Erstellen leistungsstarker, skalierbarer und kostengünstiger Anwendungen.

Was sind HTTP-Trigger?

Ein HTTP-Trigger ermöglicht es Ihnen, Ihre Cloud Function als Reaktion auf eine HTTP-Anfrage auszuführen. Im Wesentlichen, wenn eine HTTP-Anfrage an eine bestimmte URL gesendet wird, führt Google Cloud Functions die zugehörige Funktion automatisch aus. Dies macht HTTP-Trigger ideal für den Aufbau von APIs, Webhooks und ereignisgesteuerten Webanwendungen.

Hauptvorteile der Verwendung von HTTP-Triggern:

Erstellen einer Cloud Function mit einem HTTP-Trigger

Gehen wir den Prozess der Erstellung einer einfachen Cloud Function mit einem HTTP-Trigger durch. Wir werden eine Funktion erstellen, die mit der Nachricht „Hallo, Welt!“ antwortet. Dieses Beispiel kann für verschiedene globale Regionen angepasst werden, indem einfach die Ausgabestelle geändert wird.

Voraussetzungen:

Schritte:

  1. Neues Projekt erstellen (falls nicht vorhanden):

    Wenn Sie noch kein GCP-Projekt haben, erstellen Sie eines in der Google Cloud Console.

  2. Cloud Functions API aktivieren:

    Navigieren Sie in der Cloud Console zur Cloud Functions API und aktivieren Sie sie.

  3. Funktionsverzeichnis erstellen:

    Erstellen Sie ein neues Verzeichnis für Ihre Cloud Function. Zum Beispiel:

    mkdir hello-http
cd hello-http
  4. Funktionscode schreiben:

    Erstellen Sie eine Datei namens `main.py` (oder `index.js` für Node.js) mit dem folgenden Code:

    Python (main.py):

    def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        .
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return f'Hello, {name}!'

    Node.js (index.js):

    exports.helloHttp = (req, res) => {
  let name = 'World';
  if (req.body.name) {
    name = req.body.name;
  } else if (req.query.name) {
    name = req.query.name;
  }
  res.status(200).send(`Hello, ${name}!`);
};
  5. Erstellen einer Requirements-Datei (nur Python):

    Wenn Sie Python verwenden, erstellen Sie eine Datei namens `requirements.txt` und fügen Sie alle Abhängigkeiten hinzu, die Ihre Funktion benötigt. Für dieses Beispiel ist dies nicht unbedingt erforderlich, aber es ist eine gute Praxis, eine einzuschließen. Sie können sie leer lassen, wenn Sie keine Abhängigkeiten haben.

  6. Funktion bereitstellen:

    Verwenden Sie den Befehl `gcloud functions deploy`, um Ihre Funktion bereitzustellen. Ersetzen Sie `YOUR_FUNCTION_NAME` durch den gewünschten Namen für Ihre Funktion.

    Python:

    gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --allow-unauthenticated

    Node.js:

    gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime nodejs16 \
    --trigger-http \
    --allow-unauthenticated

    Erläuterung der Parameter:

    • `YOUR_FUNCTION_NAME`: Der Name, den Sie Ihrer Cloud Function geben möchten.
    • `--runtime`: Die Laufzeitumgebung für Ihre Funktion (z.B. `python39`, `nodejs16`).
    • `--trigger-http`: Gibt an, dass die Funktion durch HTTP-Anfragen ausgelöst werden soll.
    • `--allow-unauthenticated`: Erlaubt jedem, die Funktion ohne Authentifizierung aufzurufen. Warnung: Seien Sie vorsichtig, wenn Sie dies in Produktionsumgebungen aktivieren! Erwägen Sie die Implementierung einer ordnungsgemäßen Authentifizierung und Autorisierung.
  7. Funktion testen:

    Nach der Bereitstellung gibt der Befehl `gcloud` die URL Ihrer Funktion aus. Sie können sie dann testen, indem Sie eine HTTP-Anfrage an diese URL mit einem Tool wie `curl` oder Postman senden.

    curl YOUR_FUNCTION_URL

    Sie sollten die Nachricht „Hallo, Welt!“ in der Antwort sehen. Sie können auch einen Namen als Abfrageparameter übergeben:

    curl \"YOUR_FUNCTION_URL?name=YourName\"

    Dies sollte „Hallo, YourName!“ zurückgeben.

Verstehen der HTTP-Anfrage und -Antwort

Wenn eine Cloud Function durch eine HTTP-Anfrage ausgelöst wird, empfängt sie ein Objekt mit Informationen über die Anfrage. Dieses Objekt enthält typischerweise:

Ihre Funktion sollte dann eine HTTP-Antwort zurückgeben, die Folgendes umfasst:

Beispiel: Umgang mit verschiedenen HTTP-Methoden

Hier ist ein Beispiel, wie Sie verschiedene HTTP-Methoden in Ihrer Cloud Function handhaben können:

Python (main.py):

from flask import escape

def http_method(request):
    """Responds to any HTTP request.
    Args:
        request (flask.Request): HTTP request object.
    Returns:
        The response text or any set of values that can be turned into a
        Response object using
        `make_response`.
    """
    if request.method == 'GET':
        return 'This is a GET request!'
    elif request.method == 'POST':
        request_json = request.get_json(silent=True)
        if request_json and 'message' in request_json:
            message = escape(request_json['message'])
            return f'This is a POST request with message: {message}'
        else:
            return 'This is a POST request without a message.'
    else:
        return 'Unsupported HTTP method.', 405

Node.js (index.js):

exports.httpMethod = (req, res) => {
  switch (req.method) {
    case 'GET':
      res.status(200).send('This is a GET request!');
      break;
    case 'POST':
      if (req.body.message) {
        const message = req.body.message;
        res.status(200).send(`This is a POST request with message: ${message}`);
      } else {
        res.status(200).send('This is a POST request without a message.');
      }
      break;
    default:
      res.status(405).send('Unsupported HTTP method!');
      break;
  }
};

Denken Sie daran, die aktualisierte Funktion mit dem Befehl `gcloud functions deploy` bereitzustellen.

Sichern Ihrer HTTP-Trigger

Sicherheit ist bei der Arbeit mit HTTP-Triggern von größter Bedeutung, insbesondere beim Umgang mit sensiblen Daten oder kritischen Vorgängen. Hier sind einige wichtige Sicherheitsaspekte:

Authentifizierung und Autorisierung

Standardmäßig sind Cloud Functions, die durch HTTP ausgelöst werden, öffentlich zugänglich, wenn Sie `--allow-unauthenticated` verwenden. In den meisten Produktionsszenarien möchten Sie den Zugriff auf autorisierte Benutzer oder Dienste beschränken. Google Cloud bietet verschiedene Optionen für Authentifizierung und Autorisierung:

Eingabevalidierung

Validieren Sie immer die Eingabedaten, die Ihre Cloud Function empfängt, um Sicherheitslücken wie SQL-Injection oder Cross-Site-Scripting (XSS) zu verhindern. Verwenden Sie geeignete Bereinigungs- und Escaping-Techniken, um sich vor bösartigen Eingaben zu schützen.

HTTPS

Stellen Sie sicher, dass Ihre Cloud Function nur über HTTPS zugänglich ist, um die Kommunikation zwischen Client und Funktion zu verschlüsseln. Google Cloud Functions bietet automatisch HTTPS-Endpunkte.

Ratenbegrenzung

Implementieren Sie eine Ratenbegrenzung, um Missbrauch und Denial-of-Service (DoS)-Angriffe zu verhindern. Sie können Dienste wie Google Cloud Armor verwenden, um Ihre Cloud Functions vor übermäßigem Traffic zu schützen.

Anwendungsfälle für HTTP-Trigger

HTTP-Trigger sind vielseitig und können in einer Vielzahl von Anwendungen eingesetzt werden. Hier sind einige häufige Anwendungsfälle:

Beispiele aus verschiedenen Branchen

Fortgeschrittene Techniken

Verwendung von Umgebungsvariablen

Umgebungsvariablen ermöglichen es Ihnen, Ihre Cloud Function zu konfigurieren, ohne sensible Informationen oder Konfigurationswerte in Ihrem Code fest zu codieren. Sie können Umgebungsvariablen mit dem Befehl `gcloud functions deploy` oder in der Google Cloud Console festlegen.

gcloud functions deploy YOUR_FUNCTION_NAME \
    --runtime python39 \
    --trigger-http \
    --set-env-vars API_KEY=YOUR_API_KEY,DATABASE_URL=YOUR_DATABASE_URL

In Ihrem Code können Sie auf Umgebungsvariablen über das `os.environ`-Wörterbuch (Python) oder das `process.env`-Objekt (Node.js) zugreifen.

Python:

import os

def your_function(request):
    api_key = os.environ.get('API_KEY')
    # Use the API key in your function
    return f'API Key: {api_key}'

Node.js:

exports.yourFunction = (req, res) => {
  const apiKey = process.env.API_KEY;
  // Use the API key in your function
  res.status(200).send(`API Key: ${apiKey}`);
};

Handhabung asynchroner Aufgaben

Für langwierige oder rechenintensive Aufgaben ist es am besten, asynchrone Verarbeitung zu verwenden, um ein Blockieren der HTTP-Anfrage zu vermeiden. Sie können Dienste wie Google Cloud Tasks oder Cloud Pub/Sub nutzen, um diese Aufgaben in separate Warteschlangen auszulagern.

Fehlerbehandlung und Protokollierung

Implementieren Sie eine robuste Fehlerbehandlung und Protokollierung in Ihren Cloud Functions, um Probleme schnell zu identifizieren und zu beheben. Verwenden Sie Google Cloud Logging, um Protokolle von Ihren Funktionen zu sammeln und deren Leistung zu überwachen.

Best Practices

Fehlerbehebung bei häufigen Problemen

Fazit

Google Cloud Functions mit HTTP-Triggern bieten eine leistungsstarke und flexible Möglichkeit, serverlose Anwendungen zu erstellen. Indem Sie die in diesem Leitfaden erläuterten Konzepte und Techniken verstehen, können Sie die Leistungsfähigkeit von Cloud Functions nutzen, um skalierbare, kostengünstige und ereignisgesteuerte Lösungen für ein globales Publikum zu erstellen. Umarmen Sie die serverlose Revolution und entfalten Sie das volle Potenzial Ihrer Cloud-Anwendungen!

Google Cloud Functions: Ein umfassender Leitfaden zu HTTP-Triggern | MLOG